import _ from 'lodash'
import { findExpandConfList } from "@/api/authority_app/config/configInfo";
/***
 * 列表页混入类，抽出通用参数
 * 1.动态获取表格列中的字典一次性查询出来丢进一个字典对象中
 */
export const listPageMixin = {
  props: {
    // 接收一个字典数据，会合并到当前页面里
    existDictMap: {
      type: Object,
      default: () => {
        return {}
      }
    }
  },
  data() {
    return {
      // 表格上面的操作按钮组以JS形式构造
      opButtonList: ()=>{return []},
      // 显示搜索条件
      showSearch: true,
      // 数据字典
      dictMap: {},
      // 表格查询参数
      queryParams: {
      },
      // 数据表字段
      tableBindColumns: [],
      // 扩展参数父表，如果设置了则会自动查询
      extendParentKey: '',
      // 扩展字段
      extendColumns: [],
      // 扩展搜索字段
      extendSearch: [],
      // 选中数组
      ids: [],
      // 搜索组件描述JSON
      //       {
      //           dictName: ''
      //         }
      searchFormDictList: [],
      // 导出参数
      exportParams: {
        fileName: '',
        limit: 100,
        exportType: 'xlsx',
        exportWay: 'sync',
        itemList: []
      }
    };
  },
  watch: {
    // 监听变化取查询字典
    searchFormDictList() {
      this.reqDictToSet();
    },
    existDictMap: {
      handler() {

        this.mergeDictMap()
      }
    }
  },
  created() {
    this.mergeDictMap()
    this.reqDictToSet();
  },
  mounted() {
    this.reqExtendParams();
  },
  methods: {
    // 如果有传入进来的字典数据，则合并到当前
    mergeDictMap() {
      console.log('merge dict map')
      if(Object.keys(this.existDictMap).length > 0) {
        for(let key of Object.keys(this.existDictMap)) {
          this.dictMap[key] = this.existDictMap[key]
        }
      }
    },
    getDictMap() {
      return this.dictMap;
    },
    reqExtendParams() {
      if(this.extendParentKey) {
        findExpandConfList(this.extendParentKey).then((res) => {

          let tempExtendColumns = res.result;
          if (tempExtendColumns && tempExtendColumns.length) {
            let dictCodeList = [];
            const extendColumns = []
            for (let item of tempExtendColumns) {
              if(!item)
                continue;
              if (item.isTableShow == 1) {
                extendColumns.push({
                  key: item.prop,
                  id: item.id,
                  prop: item.paramCode,
                  label: item.paramName,
                  dictCode: item.dictCode ? item.dictCode : '',
                  isExtend: true,
                  visible: true,
                  extension: item.extension ? JSON.parse(item.extension) : undefined,
                  componentType: item.componentType,
                });
              }
              // 3 和 4 是选择框数据来自字典 ，提取字典进行加载
              if (
                item.componentType == 3 ||
                (item.componentType == 4 && item.dictCode)
              ) {
                if(Object.keys(this.dictMap).indexOf(item.dictCode) < 0) {
                  dictCodeList.push(item.dictCode)
                }
              }

              if(item.isSearch) {
                this.extendSearch.push(item);
              }
            }
            this.extendColumns = extendColumns;
            this.searchFormDictList.push(...dictCodeList)
          }
        });
      }
    },
    reqDictToSet() {
      let dictCodeList = []
      // 动态取出 字典列 去加载字典
      this.tableBindColumns.filter(x => x.dictCode).forEach(x => {
        dictCodeList.push(x.dictCode)
      });
      // 搜索组件中需要用的字典数据
      this.searchFormDictList.forEach(x => {
        if(dictCodeList.indexOf(x) < 0) {
          dictCodeList.push(x)
        }
      });
      let dictKeyList =  [];
      // 字典Key去重
      for(let key of dictCodeList) {
        if(Object.keys(this.dictMap).indexOf(key) > -1)
          continue
        else
          dictKeyList.push(key)
      }
      if(dictKeyList.length) {
        this.getDictsList(dictKeyList).then((res) => {
          if(res.result && Object.keys(res.result)) {
            for(let key of Object.keys(res.result)) {
              this.$set(this.dictMap,key,res.result[key])
            }
          }
        });
      }
    },
    doQuery(eventKey = '') {
      this.$EventBus.$emit(`${this.$route.path}${eventKey}` , this.queryParams);
    },
    // 多选框选中数据
    handleSelectionChange(selection) {
      this.ids = selection.map((item) => item.id);
    },
    updateShowSearch(state) {
      this.showSearch = state;
    },
    // 初始化搜索表单的枚举
    initSearchFormDicts(dictCodeList) {
      // 加载数据字典
      this.getDictsList(dictCodeList).then((res) => {
        if(res.result && Object.keys(res.result).length) {
          for (let dictCode of Object.keys(res.result)) {
            // 更新到数据字典对象中
            this.$set(this.dictMap,dictCode,res.result[dictCode])
          }
        }
      });
    },
    /**
     * 用于区分表格行复选框是否可选择
     * 返回 true 为可选择, false 为不可选择
     * @param row
     * @returns {boolean}
     */
    selectable(row) {
      return true;
    },
    // 预留统一查询方法
    getList() {
    },
    /**
     * 表格字段值处理逻辑
     * @param row
     * @param prop
     * @param text
     * @param index
     * @returns {string|*|string}
     */
    tableItemText(row,prop,text,index) {

      if(!prop) return '';
      let tempColumn = this.tableBindColumns.find(x => x.prop == prop);
      if(tempColumn && tempColumn.dictCode && this.dictMap[tempColumn.dictCode])  {
        let item = this.dictMap[tempColumn.dictCode].find(x => x.value == text);
        return item ? item.text : '';
      }
      if(tempColumn && tempColumn.formatter) {
        return tempColumn.formatter(row,text,index)
      }
      let childProp = prop.split('.')
      if(childProp && childProp.length > 1) {
        let base = row;
        for(let tempKey of childProp) {
          if(base[tempKey])
            base = base[tempKey];
          else
            return ''
        }
        return _.unescape(base);
      }
      return _.unescape(text);
    },
    // 弹出层操作完成回调 (可重写)
    editComplete(state) {
      if(state) {
        // 编辑完成，刷新列表数据
        this.doQuery()
      }
    },
    // 表格数据加载完成回调 (可重写)
    dataLoadComplete(res) {},
    // 表格数据加载异常回调 (可重写)
    dataLoadError(res) {},
  }
}
